package us.proyecto.canarios.actions.admin;

import static org.jboss.seam.ScopeType.SESSION;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;

import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Begin;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Logger;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Observer;
import org.jboss.seam.annotations.Out;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.faces.FacesContext;
import org.jboss.seam.log.Log;
import org.jboss.seam.security.Identity;
import org.richfaces.component.html.HtmlTree;
import org.richfaces.event.NodeSelectedEvent;
import org.richfaces.model.TreeNode;
import org.richfaces.model.TreeNodeImpl;

import us.proyecto.canarios.dao.ConcursoDAO;
import us.proyecto.canarios.dao.UsuarioDAO;
import us.proyecto.canarios.domain.Concurso;
import us.proyecto.canarios.domain.Criador;
import us.proyecto.canarios.domain.Juez;
import us.proyecto.canarios.domain.JuezConcurso;
import us.proyecto.canarios.domain.Usuario;

@Name("autenticacion")
@SuppressWarnings({ "unchecked", "unused" })
@Scope(ScopeType.SESSION)
public class AutenticacionAction {
	@In
	EntityManager em;

	@In
	private Identity identity;

	@In(create = true)
	private UsuarioDAO usuarioDAO;

	@In(create = true)
	private ConcursoDAO concursoDAO;

	@Out(required = false, scope = SESSION)
	private Usuario user;

	@Logger
	private static Log log;

	private boolean invit = false;

	private TreeNode<Concurso> rootNode = null;
	private String nodeTitle;
	private List<String> selectedNodeChildren = new ArrayList<String>();

	private TreeNodeImpl<Concurso> rootNodeGrupo;
	private TreeNodeImpl<Concurso> rootNodeDocument;
	private TreeNodeImpl<Concurso> rootNodeCriador;
	private TreeNodeImpl<Concurso> rootNodeCriadorProx;
	private TreeNodeImpl<Concurso> rootNodePajaro;
	private TreeNodeImpl<Concurso> rootNodeJuezPajaro;
	private TreeNodeImpl<Concurso> rootNodeJuezGrupo;
	private TreeNodeImpl<Concurso> rootNodeConcursoCriador;
	private TreeNodeImpl<Concurso> rootNodeConcursoCriadorProx;
	private TreeNodeImpl<Concurso> rootNodeConcursoAsoc;

	private TreeNodeImpl<Concurso> rootNodeJuezPajaroPasados;

	private TreeNodeImpl<Concurso> rootNodeJuezPajaroProximos;
	private TreeNodeImpl<Concurso> rootNodeJuezGrupoPasados;
	private TreeNodeImpl<Concurso> rootNodeJuezGrupoProximos;

	private TreeNodeImpl<Concurso> rootNodeDocumentPasados;

	private TreeNodeImpl<Concurso> rootNodeDocumentProximos;

	private TreeNodeImpl<Concurso> rootNodePajaroPasados;

	private TreeNodeImpl<Concurso> rootNodePajaroProximos;

	private TreeNodeImpl<Concurso> rootNodeConcursoAsocPasados;

	private TreeNodeImpl<Concurso> rootNodeConcursoAsocProximos;

	private static final String DATA_PATH = "/richfaces/tree/examples/simple-tree-data.properties";

	// @Begin(join=true)
	public boolean autenticar() {
		/*
		 * List
		 * listaObjetos=em.createQuery("select u from Usuario u").getResultList
		 * (); Iterator it=listaObjetos.iterator(); while(it.hasNext()){ Usuario
		 * aux=(Usuario)it.next(); log.info(aux.getNombre()); }
		 */
		invit = false;
			List<Usuario> results = usuarioDAO
					.getListbywhere(" nombre= #{identity.username} and pass = #{identity.password} and pendiente != true");
			if (results.size() == 0) {
				return false;
			} else {
				user = (Usuario) results.get(0);
				if (user.getAdministrador()) {
					identity.addRole("Administrador");
				} else if (user.getEsAsociacion()) {
					identity.addRole("Asociacion");
					identity.addRole("Usuario genérico");
				} else if (user.getEsCriador()) {
					identity.addRole("Criador");
					identity.addRole("Usuario genérico");
				} else if (user.getEsJuez()) {
					identity.addRole("Juez");
					identity.addRole("Usuario genérico");
				}
				return true;
			}
	}

	@Observer("org.jboss.seam.security.alreadyLoggedIn")
	@Begin(join = true)
	public void alreadyLoggedIn() {
		log.info("Ya estas conectado");
	}

	private void addNodes(String texto, TreeNode node, String tipo) {
		boolean end = false;
		int counter = 2;
		String where = new String(" 1 = 1 ");
		List<Concurso> listaConcursos = new ArrayList<Concurso>();
		List<Concurso> listaConcursosAux = new ArrayList<Concurso>();
		if (user.getAsociacion() != null) {
			where = where + " and c.asociacion.idAsociacion = "
					+ user.getAsociacion().getIdAsociacion();
			listaConcursosAux = concursoDAO.getListByWhere(where);
			if(tipo.equals("Vigentes")){
				for(Concurso c:listaConcursosAux){
					Calendar dInicioInscrip = new GregorianCalendar();
					dInicioInscrip.setTime(c.getFechaInicio());

					Calendar dFinInscrip = new GregorianCalendar();
					dFinInscrip.setTime(c.getFechaInicio());
					dFinInscrip.add(Calendar.DAY_OF_MONTH, 1);
					Calendar dActual = new GregorianCalendar();
					if(dInicioInscrip.before(dActual) && dFinInscrip.after(dActual)){
						listaConcursos.add(c);
					}
				}
			}else if(tipo.equals("Pasados")){
				for(Concurso c:listaConcursosAux){
					Calendar dInicioInscrip = new GregorianCalendar();
					dInicioInscrip.setTime(c.getFechaInicio());

					Calendar dFinInscrip = new GregorianCalendar();
					dFinInscrip.setTime(c.getFechaInicio());
					dFinInscrip.add(Calendar.DAY_OF_MONTH, 1);
					Calendar dActual = new GregorianCalendar();
					if(dInicioInscrip.before(dActual) && dFinInscrip.before(dActual)){
						listaConcursos.add(c);
					}
				}
			}else if(tipo.equals("Proximos")){
				for(Concurso c:listaConcursosAux){
					Calendar dInicioInscrip = new GregorianCalendar();
					dInicioInscrip.setTime(c.getFechaInicio());

					Calendar dFinInscrip = new GregorianCalendar();
					dFinInscrip.setTime(c.getFechaInicio());
					dFinInscrip.add(Calendar.DAY_OF_MONTH, 1);
					Calendar dActual = new GregorianCalendar();
					if(dInicioInscrip.after(dActual) && dFinInscrip.after(dActual)){
						listaConcursos.add(c);
					}
				}
			}
			/*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date d = new Date();
			where = where + " and c.fechaInicio <= convert('" + sdf.format(d)
					+ " ', DATE) ";
			where = where + " and c.fechaFin >= convert('" + sdf.format(d)
					+ " ', DATE) ";*/
//			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//			Date d = new Date();
//			where = where + " and c.fechaInicio <= convert('" + sdf.format(d)
//					+ " ', DATE) ";
//			where = where + " and c.fechaFin >= convert('" + sdf.format(d)
//					+ " ', DATE) ";
		}else if(user.getJuez() != null) {
			Juez j = usuarioDAO.getJuez(user.getJuez());
			listaConcursos = new ArrayList<Concurso>();
			if(tipo.equals("Vigentes")){
				for(JuezConcurso c: j.getJuecesConcurso()){
					Calendar dInicioEnjuiz = new GregorianCalendar();
					dInicioEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dInicioEnjuiz.add(Calendar.DAY_OF_MONTH, 1);

					Calendar dFinEnjuiz = new GregorianCalendar();
					dFinEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dFinEnjuiz.add(Calendar.DAY_OF_MONTH, 2);
					Calendar dActual = new GregorianCalendar();
					if(dInicioEnjuiz.before(dActual) && dFinEnjuiz.after(dActual)){
						listaConcursos.add(c.getConcurso());
					}
				}
			}else if(tipo.equals("Pasados")){
				for(JuezConcurso c: j.getJuecesConcurso()){
					Calendar dInicioEnjuiz = new GregorianCalendar();
					dInicioEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dInicioEnjuiz.add(Calendar.DAY_OF_MONTH, 2);

					Calendar dFinEnjuiz = new GregorianCalendar();
					dFinEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dFinEnjuiz.add(Calendar.DAY_OF_MONTH, 3);
					Calendar dActual = new GregorianCalendar();
					if(dInicioEnjuiz.before(dActual) && dFinEnjuiz.before(dActual)){
						listaConcursos.add(c.getConcurso());
					}
				}
			}else if(tipo.equals("Proximos")){
				for(JuezConcurso c: j.getJuecesConcurso()){
					Calendar dInicioEnjuiz = new GregorianCalendar();
					dInicioEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dInicioEnjuiz.add(Calendar.DAY_OF_MONTH, 2);

					Calendar dFinEnjuiz = new GregorianCalendar();
					dFinEnjuiz.setTime(c.getConcurso().getFechaInicio());
					dFinEnjuiz.add(Calendar.DAY_OF_MONTH, 3);
					Calendar dActual = new GregorianCalendar();
					if(dInicioEnjuiz.after(dActual) && dFinEnjuiz.after(dActual)){
						listaConcursos.add(c.getConcurso());
					}
				}
			}

		}else if(user.getCriador() != null) {
			Criador c = usuarioDAO.getCriador(user.getCriador());
			if(texto.equalsIgnoreCase("mis concursos")){
			    Date d = new Date();
				listaConcursos = usuarioDAO.getlistaConcursos(c);
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                //String where1 = "c.fechaInicio > '" + sdf.format(d)+"'";
                //listaConcursos = concursoDAO.getListByWhere(where1);
			}else{
				Date d = new Date();
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				String where1 = "c.fechaInicio > '" + sdf.format(d)+"'";
				listaConcursos = concursoDAO.getListByWhere(where1);
				if(listaConcursos == null || listaConcursos.size()==0){
					Concurso c1 = new Concurso();
					c1.setNombre("No hay concursos proximamente");
					listaConcursos.add(c1);
				}
			}
		}

		// while (!end) {
		// String key = path != null ? path + '.' + counter :
		// String.valueOf(counter);

		// String value = properties.getProperty(key);
		// if (value != null) {
		TreeNodeImpl<Concurso> nodeImpl = new TreeNodeImpl<Concurso>();
		Concurso c1= new Concurso();
		c1.setNombre(texto);
		nodeImpl.setData(c1);
		node.addChild(c1.getIdConcurso(), nodeImpl);
		if(listaConcursos != null) {
			for(Concurso c:listaConcursos){
				TreeNodeImpl<Concurso> nodeImpl1 = new TreeNodeImpl<Concurso>();
				nodeImpl1.setData(c);

				nodeImpl.addChild(c.getIdConcurso(), nodeImpl1);
				//counter++;
			}
			if(listaConcursos.size()==0){
				TreeNodeImpl<Concurso> nodeImpl1 = new TreeNodeImpl<Concurso>();
				Concurso c2= new Concurso();
				c2.setNombre("No hay ningun elemento que cumpla las condiciones");
				nodeImpl1.setData(c2);
				nodeImpl.addChild(0, nodeImpl1);
			}
		}


		/*
		 * } else { end = true; }
		 */
		// }
	}

	private void loadTree() {
		rootNode = new TreeNodeImpl<Concurso>();
		addNodes("Añadir individual", rootNode,"Vigentes");
	}

	public TreeNode<Concurso> getTreeNode() {
		if (rootNode == null) {
			loadTree();
		}

		return rootNode;
	}


	public TreeNode<Concurso> getTreeNodeGrupo() {
		if (rootNodeGrupo == null) {
			loadTreeGrupo();
		}

		return rootNodeGrupo;
	}
	public TreeNode<Concurso> getTreeNodeDocument() {
		if (rootNodeDocument == null) {
			loadTreeDocument();
		}

		return rootNodeDocument;
	}

	public TreeNode<Concurso> getTreeNodeDocumentPasados() {
		if (rootNodeDocumentPasados == null) {
			loadTreeDocumentPasados();
		}

		return rootNodeDocumentPasados;
	}

	public TreeNode<Concurso> getTreeNodeDocumentProximos() {
		if (rootNodeDocumentProximos == null) {
			loadTreeDocumentProximos();
		}

		return rootNodeDocumentProximos;
	}

	public TreeNode<Concurso> getTreeNodeCriador() {
		if (rootNodeCriador == null) {
			loadTreeCriador();
		}

		return rootNodeCriador;
	}

	public TreeNode<Concurso> getTreeNodeCriadorProx() {
		if (rootNodeCriadorProx == null) {
			loadTreeCriadorProx();
		}

		return rootNodeCriadorProx;
	}

	public TreeNode<Concurso> getTreeNodePajaro() {
		if (rootNodePajaro== null) {
			loadTreePajaro();
		}

		return rootNodePajaro;
	}
	public TreeNode<Concurso> getTreeNodePajaroPasados() {
		if (rootNodePajaroPasados== null) {
			loadTreePajaroPasados();
		}

		return rootNodePajaroPasados;
	}
	public TreeNode<Concurso> getTreeNodePajaroProximos() {
		if (rootNodePajaroProximos== null) {
			loadTreePajaroProximos();
		}

		return rootNodePajaroProximos;
	}

	public TreeNode<Concurso> getTreeNodeJuezPajaro() {
		if (rootNodeJuezPajaro== null) {
			loadTreeJuezPajaro();
		}

		return rootNodeJuezPajaro;
	}

	public TreeNode<Concurso> getTreeNodeJuezPajaroPasados() {
		if (rootNodeJuezPajaroPasados== null) {
			loadTreeJuezPajaroPasados();
		}

		return rootNodeJuezPajaroPasados;
	}
	public TreeNode<Concurso> getTreeNodeJuezPajaroProximos() {
		if (rootNodeJuezPajaroProximos== null) {
			loadTreeJuezPajaroProximos();
		}

		return rootNodeJuezPajaroProximos;
	}

	public TreeNode<Concurso> getTreeNodeJuezGrupoPasados() {
		if (rootNodeJuezGrupoPasados== null) {
			loadTreeJuezGrupoPasados();
		}

		return rootNodeJuezGrupoPasados;
	}
	public TreeNode<Concurso> getTreeNodeJuezGrupoProximos() {
		if (rootNodeJuezGrupoProximos== null) {
			loadTreeJuezGrupoProximos();
		}

		return rootNodeJuezGrupoProximos;
	}


	public TreeNode<Concurso> getTreeNodeJuezGrupo() {
		if (rootNodeJuezGrupo== null) {
			loadTreeJuezGrupo();
		}

		return rootNodeJuezGrupo;
	}

	public TreeNode<Concurso> getTreeNodeConcursoAsoc() {
		if (rootNodeConcursoAsoc== null) {
			loadTreeConcursoAsoc();
		}

		return rootNodeConcursoAsoc;
	}
	public TreeNode<Concurso> getTreeNodeConcursoAsocProximos() {
		if (rootNodeConcursoAsocProximos== null) {
			loadTreeConcursoAsocProximos();
		}

		return rootNodeConcursoAsocProximos;
	}
	public TreeNode<Concurso> getTreeNodeConcursoAsocPasados() {
		if (rootNodeConcursoAsocPasados== null) {
			loadTreeConcursoAsocPasados();
		}

		return rootNodeConcursoAsocPasados;
	}

	private void loadTreeConcursoAsoc() {
		rootNodeConcursoAsoc = new TreeNodeImpl<Concurso>();
		addNodes("Gestionar Concursos", rootNodeConcursoAsoc,"Vigentes");
	}
	private void loadTreeConcursoAsocPasados() {
		rootNodeConcursoAsocPasados = new TreeNodeImpl<Concurso>();
		addNodes("Consultar Concursos", rootNodeConcursoAsocPasados,"Pasados");
	}
	private void loadTreeConcursoAsocProximos() {
		rootNodeConcursoAsocProximos = new TreeNodeImpl<Concurso>();
		addNodes("Gestionar Concursos", rootNodeConcursoAsocProximos,"Proximos");
	}

	private void loadTreeGrupo() {
		rootNodeGrupo = new TreeNodeImpl<Concurso>();
		addNodes("Añadir Equipos", rootNodeGrupo,"Vigentes");
	}
	private void loadTreeDocument() {
		rootNodeDocument = new TreeNodeImpl<Concurso>();
		addNodes("Generación documentación", rootNodeDocument,"Vigentes");
	}
	private void loadTreeDocumentPasados() {
		rootNodeDocumentPasados = new TreeNodeImpl<Concurso>();
		addNodes("Generación documentación", rootNodeDocumentPasados,"Pasados");
	}

	private void loadTreeDocumentProximos() {
		rootNodeDocumentProximos = new TreeNodeImpl<Concurso>();
		addNodes("Generación documentación", rootNodeDocumentProximos,"Proximos");
	}
	private void loadTreeCriador() {
		rootNodeCriador = new TreeNodeImpl<Concurso>();
		addNodes("Mis Concursos", rootNodeCriador,"Vigentes");
	}

	private void loadTreeCriadorProx() {
		rootNodeCriadorProx = new TreeNodeImpl<Concurso>();
		addNodes("Próximos concursos", rootNodeCriadorProx,"Vigentes");
	}
	private void loadTreePajaro() {
		rootNodePajaro = new TreeNodeImpl<Concurso>();
		addNodes("Gestion pajaros", rootNodePajaro,"Vigentes");
	}
	private void loadTreePajaroPasados() {
		rootNodePajaroPasados = new TreeNodeImpl<Concurso>();
		addNodes("Gestion pajaros", rootNodePajaroPasados,"Pasados");
	}
	private void loadTreePajaroProximos() {
		rootNodePajaroProximos = new TreeNodeImpl<Concurso>();
		addNodes("Gestion pajaros", rootNodePajaroProximos,"Proximos");
	}

	private void loadTreeJuezPajaro() {
		rootNodeJuezPajaro = new TreeNodeImpl<Concurso>();
		addNodes("Evaluar individuales", rootNodeJuezPajaro,"Vigentes");
	}

	private void loadTreeJuezPajaroPasados() {
		rootNodeJuezPajaroPasados = new TreeNodeImpl<Concurso>();
		addNodes("Consultar individuales", rootNodeJuezPajaroPasados,"Pasados");
	}

	private void loadTreeJuezPajaroProximos() {
		rootNodeJuezPajaroProximos = new TreeNodeImpl<Concurso>();
		addNodes("Consultar individuales", rootNodeJuezPajaroProximos,"Proximos");
	}

	private void loadTreeJuezGrupoPasados() {
		rootNodeJuezGrupoPasados = new TreeNodeImpl<Concurso>();
		addNodes("Consultar Equipos", rootNodeJuezGrupoPasados,"Pasados");
	}

	private void loadTreeJuezGrupoProximos() {
		rootNodeJuezGrupoProximos = new TreeNodeImpl<Concurso>();
		addNodes("Consultar Equipos", rootNodeJuezGrupoProximos,"Proximos");
	}

	private void loadTreeJuezGrupo() {
		rootNodeJuezGrupo = new TreeNodeImpl<Concurso>();
		addNodes("Evaluar Equipos", rootNodeJuezGrupo,"Vigentes");
	}




	public String getNodeTitle() {
		return nodeTitle;
	}

	public void setNodeTitle(String nodeTitle) {
		this.nodeTitle = nodeTitle;
	}

	@Begin(join = true)
	public void invitado(){
		user = new Usuario();
		invit = true;
	}

	public boolean isInvit() {
		return invit;
	}

	public void setInvit(boolean invitado) {
		this.invit = invitado;
	}


}